package com.example.rabc.monitor;

import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 指标聚合处理器，用于聚合和计算性能指标
 */
@Component
public class MetricsAggregator implements MonitorObserver {
    private final Map<String, List<Double>> performanceMetrics = new ConcurrentHashMap<>(); // 存储每个方法的执行时间列表

    /**
     * 处理方法性能事件，将执行时间添加到对应方法的指标列表中
     * @param event 监控事件
     */
    @Override
    public void update(MonitorEvent event) {
        if ("METHOD_PERFORMANCE".equals(event.getEventType())) {
            Map<String, Object> data = event.getData();
            String method = (String) data.get("method");
            Number executionTime = (Number) data.get("executionTime");
            
            if (method != null && executionTime != null) {
                performanceMetrics.computeIfAbsent(method, k -> new ArrayList<>())
                                 .add(executionTime.doubleValue());
                
                // 保留最近100个数据点
                List<Double> metrics = performanceMetrics.get(method);
                if (metrics.size() > 100) {
                    metrics.remove(0);
                }
            }
        }
    }

    /**
     * 获取所有方法的平均执行时间
     * @return 方法名到平均执行时间的映射
     */
    public Map<String, Double> getAverageExecutionTimes() {
        Map<String, Double> averages = new HashMap<>();
        for (Map.Entry<String, List<Double>> entry : performanceMetrics.entrySet()) {
            List<Double> times = entry.getValue();
            double average = times.stream().mapToDouble(Double::doubleValue).average().orElse(0.0);
            averages.put(entry.getKey(), average);
        }
        return averages;
    }


    /**
     * 判断是否支持处理指定类型的事件
     * @param eventType 事件类型
     * @return 是否支持
     */
    @Override
    public boolean supportsEventType(String eventType) {
        return "METHOD_PERFORMANCE".equals(eventType);
    }
}